package org.telegram.bot.handle.service;

import com.alibaba.fastjson2.JSONObject;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.telegram.bot.emums.BotCommonEnums;
import org.telegram.bot.handle.IBotSendMessage;
import org.telegram.bot.handle.IMessageHandle;
import org.telegram.bot.service.*;
import org.telegram.telegrambots.meta.api.methods.groupadministration.ApproveChatJoinRequest;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.ChatJoinRequest;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.api.objects.chat.Chat;

/**
 * @Author: wyx
 * @Date: 2023/5/27 21:39
 */
@Slf4j
@Service
public class MessageHandleImpl implements IMessageHandle, IBotSendMessage {

    @Resource
    private IMessageService messageService;

    @Resource
    private IEditedMessageService editedMessageService;
    
    @Resource
    private ILeftGroupService leftGroupService;
    
    @Resource
    private IJoinGroupService joinGroupService;
    
    @Resource
    private IForwardFromChatService forwardFromChatService;
    
    @Resource
    private IBotGroupService botGroupService;
    
    @Resource
    private ICommandService commandService;

    /**
     * 处理普通消息
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botId 机器人ID
     */
    @Override
    public void message(Update update, Long chatId, String botId) {
        messageService.handle(update, chatId, botId);
    }
    
    /**
     * 处理编辑后的消息
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botName 机器人名称
     */
    @Override
    public void editedMessage(Update update, Long chatId, String botName) {
        editedMessageService.handle(update, chatId, botName);
    }
    
    /**
     * 处理用户离开聊天
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botName 机器人名称
     */
    @Override
    public void leftChat(Update update, Long chatId, String botName) {
        leftGroupService.handle(update, chatId, botName);
    }
    
    /**
     * 处理新成员加入聊天
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botName 机器人名称
     */
    @Override
    public void newChatMembers(Update update, Long chatId, String botName) {
        joinGroupService.handle(update, chatId, botName);
    }
    
    /**
     * 处理从其他聊天转发的消息
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botName 机器人名称
     */
    @Override
    public void forwardFromChat(Update update, Long chatId, String botName) {
        forwardFromChatService.handle(update, chatId, botName);
    }
    
    /**
     * 处理机器人加入群组
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botId 机器人ID
     */
    @Override
    public void botJoinGroup(Update update, Long chatId, String botId) {
        Chat chat = update.getMyChatMember().getChat();
        log.info("机器人加入群组: chatId={}, botId={}", chatId, botId);
        commandService.start(chat, botId, "初始化群组信息...\n如需管理群组请授予机器人管理员身份。");
        updateGroupInfo(botId, chat);
    }
    
    /**
     * 处理机器人离开群组
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botId 机器人ID
     */
    @Override
    public void botLeftGroup(Update update, Long chatId, String botId) {
        log.info("机器人离开群组: chatId={}, botId={}", chatId, botId);
        botGroupService.clearGroup(botId, update.getMyChatMember().getChat().getId());
    }
    
    /**
     * 处理机器人被授予管理员权限
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botId 机器人ID
     */
    @Override
    public void botAddAdmin(Update update, Long chatId, String botId) {
        botGroupService.updateTelegramGroup(botId, update.getMyChatMember().getChat());
    }
    
    /**
     * 处理机器人失去管理员权限
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botId 机器人ID
     */
    @Override
    public void botCancelAdmin(Update update, Long chatId, String botId) {
        send(botId, SendMessage.builder()
                .chatId(chatId)
                .text("检测到权限发生改变，如需管理群组，请授予管理员权限。")
                .build());
    }
    
    /**
     * 处理机器人命令
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botId 机器人ID
     */
    @Override
    public void botCommand(Update update, Long chatId, String botId) {
        commandService.handle(update, chatId, botId);
    }
    
    /**
     * 处理群组类型变更
     * @param update 更新对象
     * @param chatId 聊天ID
     * @param botId 机器人ID
     */
    @Override
    public void groupTypeChange(Update update, Long chatId, String botId) {
        if (update.getMessage() == null || update.getMessage().getSenderChat() == null) {
            log.warn("无效的 update 或 sender chat: update={}, chatId={}, botId={}", update, chatId, botId);
            return;
        }
        if (BotCommonEnums.CHAT_ROLE_GROUP_ANONYMOUS_BOT.equals(update.getMessage().getFrom().getUserName())
                && update.getMessage().getFrom().getIsBot()
                && update.getMessage().getMigrateFromChatId() != null
                && !update.getMessage().getMigrateFromChatId().equals(update.getMessage().getChatId())) {
            //1、群组变更类型时候会先发一条邀请机器人入群的信息
            //2、第二步会由官方的GroupAnonymousBot发送群类型变更信息(当前步骤会进入到这里)
            //3、最后有原群身份发送一条变更信息
            int i = botGroupService.updateChatId(chatId, update.getMessage().getMigrateFromChatId());
            log.error("消息：超级组2组{}数据：chatId={}, botId={}", i, chatId, botId);
            if (i > 0) {
                updateGroupInfo(botId, update.getMessage().getChat());
            }
        }
    }
    
    /**
     * 处理群组升级为超级群组
     * @param chat 群组对象
     * @param groupChatId 原群组ID
     * @param superGroupChatId 新超级群组ID
     * @param botId 机器人ID
     */
    @Override
    public void groupToSuperGroup(Chat chat, Long groupChatId, Long superGroupChatId, String botId) {
        if (groupChatId == null || superGroupChatId == null || chat == null) {
            log.error("无效的参数: groupChatId={}, superGroupChatId={}, chat={}, botId={}", groupChatId, superGroupChatId, chat, botId);
            return;
        }
        int i = botGroupService.updateChatId(superGroupChatId, groupChatId);
        if (i > 0) {
            chat.setId(superGroupChatId);
            chat.setType(BotCommonEnums.CHAT_TYPE_SUPERGROUP);
            log.error("消息：组2超级组数据：chat={}, botId={}", JSONObject.toJSONString(chat), botId);
            updateGroupInfo(botId, chat);
        }
    }
    
    /**
     * 处理聊天加入请求
     * @param chatJoinRequest 加入请求对象
     * @param botId 机器人ID
     */
    @Override
    public void chatJoinRequest(ChatJoinRequest chatJoinRequest, String botId) {
        send(botId, ApproveChatJoinRequest.builder()
                                          .chatId(chatJoinRequest.getChat().getId())
                                          .userId(chatJoinRequest.getUser().getId())
                                          .build());
    }

    /**
     * 更新群组信息
     * @param botId 机器人ID
     * @param chat 群组对象
     */
    private void updateGroupInfo(String botId, Chat chat) {
        botGroupService.updateTelegramGroup(botId, chat);
    }
}
